{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 分类学习"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 机器学习的HelloWorld ，一个新的分类算法，都会看看在MNIST的上的执行结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# struct模块的打包函数，i是打包为integer格式，一个数占4个字节. 用b打包为一个字节\n",
    "import struct\n",
    "struct.pack('>i',2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./g1.png)\n",
    "![jupyter](./g2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "import struct\n",
    "# .gz是源文件，解压后才能读取\n",
    "with open('./MNIST_data/train-images-idx3-ubyte', 'rb') as f:\n",
    "    buffer = f.read(4*4) # 4个int，根据图片g1中训练集数据定义，前面4个数每个4字节，表征基础信息。第5个数开始是像素信息\n",
    "    # 一张图片由28*28（行乘高）像素组成\n",
    "    head = struct.unpack('>iiii',buffer)  # iiii表示解包出4个int类型\n",
    "    print(head)\n",
    "    length = head[1] * head[2]  * head[3]  # 一共60000张图片，每张图片是28*28像素，故length是总像素数\n",
    "    print(length)\n",
    "    buffer = f.read(length)\n",
    "#   print(buffer)\n",
    "    data = struct.unpack('>{}B'.format(length),buffer)  #{}是占位符，用length代，B表示byte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 显示图片\n",
    "import numpy as np\n",
    "imgs = np.reshape(data,(head[1],head[2],head[3]))  # data重新塑形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape  # 60000张图片，每张图片28*28的像素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 显示图片\n",
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i],cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 另外一个较简便的数据源mnist-original.bat\n",
    "from sklearn.datasets import fetch_mldata\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')  \n",
    "# 若从网络拿数据则把data_home参数拿掉，给出完整的url"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* DESCR 数据集描述\n",
    "* data 包含一个数组，每个实例为一行，每个特征为一列\n",
    "* target 包含一个带有标签的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X为数据集，y为标签\n",
    "X, y = mnist['data'], mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape  # 60000个训练数据，10000个测试数据  行列相乘28*28=784"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 要将X数据进行拆分，分为训练集和测试集\n",
    "# 此处也可显示图片\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_digit = X[36000] # 取第36000个数据\n",
    "some_digit_image = some_digit.reshape(28, 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]  # 对应标签为5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 简单拆分，前60000个训练集，后10000个测试集\n",
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6509, 23711, 17743, ..., 25639,  5896, 17918])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "import numpy as np\n",
    "shuffle_index = np.random.permutation(60000)  #对60000个下标随机排列\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 用下标重新打乱\n",
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 二元分类器，要么‘是’要么‘非’\n",
    "\n",
    "# 识别数字5 ，二元分类5或者非5\n",
    "# 创建目标向量\n",
    "# 等于5的位置都为true，其他非5的位置都为false\n",
    "y_train_5 = (y_train == 5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False, False, False],\n",
       "       [ True, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [ True, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_5 = (y_test == 5) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD(线性分类器的一种) 梯度下降 分类器， 适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习，\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "sgd_clf = SGDClassifier(random_state = 42)  # 随机因子为42，保证每次分类结果一样\n",
    "sgd_clf.fit(X_train, y_train_5)  # 估算器的fit方法   标签用y_train_5因为只考虑二元分类\n",
    "\n",
    "sgd_clf.predict([some_digit])  # 预测some_digit这个图片是不是5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.96235, 0.962  , 0.9641 ])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "\n",
    "# 3个折叠，正确率达到 95% 以上\n",
    "# cv=3把训练集分为三份（默认cv=10），测试3次，每次测试拿两份作为训练，一份作为测试集\n",
    "# 这样测三次有三个精度\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 所有分类器都是继承于估算器\n",
    "# 把每张图都分类成 非5    非5就是正类，5就是负类\n",
    "# 用来证明精度这个单一的指标并不能完全用来评估分类器性能\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        return np.zeros((len(X), 1), dtype=bool)    # np.zeros初始化一个0矩阵，第一个参数是几行几列，现在指定只有1列，所有元素类型为bool\n",
    "        # 无论给我什么数据，我都返回一个死的数据False，要来证明精度这个单一指标并不能完全用来评估分类器性能"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.90905, 0.9091 , 0.9108 ])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf = Never5Classifier()\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间你都是正确的\n",
    "* 这说明准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据集， 某些类比其他类更为频繁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵，从多个方面评估分类器的性能\n",
    "# A类别实例被分为B类别次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列\n",
    "# 得到的是个结果，而不像cross_val_score得到的是精度\n",
    "# 当中也用到了交叉验证\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与 cross_val_score 相比\n",
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53396,  1183],\n",
       "       [ 1048,  4373]], dtype=int64)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "confusion_matrix(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 预测5所以5为正类，非5为负类\n",
    "# 第一行 第一列 53849 被正确的分为 非5 ，真负类\n",
    "# 第一行 第二列 730 被错误的分类成 5 ，假正类\n",
    "# 第二行 第一列 1611 张被错误的分为 非5， 假负类\n",
    "# 第二行 第二列 3810 张被正确的分在了5 ，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 若都用正确的标签，则达到理想的情况，分类错误的数量为0\n",
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.787077033837293"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "\n",
    "precision_score(y_train_5, y_train_pred) # 3810 / 3810 + 730"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8066777347352887"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred)    #  3810 / 3810 + 1611"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 说明 检测一张图的时候，只有78%的概率是准确的，而且只有80%的数字5 被它检测出来\n",
    "# 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "# 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7967568552427804"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "# 有时候你更关心精度，有时你能关心召回率\n",
    "# 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "# 不能同时增加精度并减少召回率，反之亦然"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'[jupyter]' 不是内部或外部命令，也不是可运行的程序\n",
      "或批处理文件。\n"
     ]
    }
   ],
   "source": [
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值（决策值），大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何设置阀值 来改变精度和召回率\n",
    "\n",
    "# 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。以LogisticRegression（逻辑回归分类器）为例\n",
    "# clf = LogisticRegression()\n",
    "# clf.fit(X_train, y_train)\n",
    "# pred_proba = clf.predict_proba(X_test)[:, 1]    # predict_proba返回每个实例属于正类的概率\n",
    "# threshold = 0.75  # 阀值设置为0.75\n",
    "# pred_label = pred_proba > threshold\n",
    "\n",
    "# pred_proba是每个实例为真的概率\n",
    "# 假设阈值是0.75\n",
    "# pred_label里True就是概率大于0.75的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-24677.92674201])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值decision_function\n",
    "# 阀值一般不能修改，但通过决策值的判断来等起到等效改变阀值的判断结果\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阀值\n",
    "# 返回决策值，而不是预测结果 （如果不设置method=\"decision_function\"则返回预测结果）\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -528892.19397477,  -496633.22751224, -1093538.68475332, ...,\n",
       "        -422988.91354345,  -385854.94770282, -1000932.88341392])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率\n",
    "y_scores.shape\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)   # 得到精度，召回，阀值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1121067.2030559 ,   730572.77273536,   727139.49505558, ...,\n",
       "       -1612628.2324625 , -1613405.53253157, -2811362.98505619])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thresholds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图  （PR曲线）\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阀值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阀值大概在60000左右 , 相当于设置了阀值为60000\n",
    "y_train_pred_90 = (y_scores > 60000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.873072625698324"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7207157351042243"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)  # zhao召回在0.6左右，与图上基本相符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC 曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 本质是 真正类率tpr和假正类率fpr（错误的分为正类的负类实例比例）\n",
    "# 与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()   # 好的分类器应该远离虚线折线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9630763608081946"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC，虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法（返回每个实例属于正类还是负类的概率），sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "# n_estimators=10使用10棵数\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 0. ],\n",
       "       [0.9, 0.1],\n",
       "       [1. , 0. ],\n",
       "       ...,\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest\n",
    "# 因为是二元分类，每组两个数，第一个表示负类的概率，第二个表示正类的概率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值：\n",
    "# y_probas_forest做切片，取第二列\n",
    "y_scores_forest = y_probas_forest[:, 1] \n",
    "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0. , ..., 0. , 0. , 0. ])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9928237563769768"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9837326885029677"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.825493451392732"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 自己绘制随机森林的PR图\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions1, recalls1, thresholds1 = precision_recall_curve(y_train_5, y_scores_forest)   # 得到精度，召回，阀值\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thresholds1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions1, recalls1, thresholds1)\n",
    "plt.xlim([0, 1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions1, recalls1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森里和朴素贝叶斯可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案\n",
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([3.])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 默认用ova进行训练\n",
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-170521.39220202, -395295.61781676, -443257.6179027 ,\n",
       "          -4422.86038483, -454173.3661003 ,  -24677.92674201,\n",
       "        -792549.77334612, -244671.32892541, -704632.20683986,\n",
       "        -583102.80928444]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别\n",
    "# 返回10个分数，每个类别1个，哪个最高哪个中标，decision_function会返回决策分数\n",
    "# 分数越高越精确，但some_digit_scores数组中的顺序不一定按0，1，2，3，4...,9来\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 拿到决策分数最高的值的索引\n",
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中（分类标签），按值大小排列，\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.argmax(some_digit_scores)通过这个值来确定分类标签中哪个值是预测值\n",
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 某些情况要用ovo优化\n",
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "# 将ova封装为ovo\n",
    "# SGDClassifier支持多分类,它以”one-vs-all(OVA)”的方式通过结合多个二分类来完成。对于K个类中的每个类来说，\n",
    "# 一个二分类器可以通过它和其它K-1个类来进行学习得到。\n",
    "# iter为迭代次数，默认为5\n",
    "# max_iter：最大迭代次数\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "ovo_clf.fit(X_train, y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 估算器个数 N*（N-1）/2个分类器  N=10\n",
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_clf.fit(X_train, y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0. , 0. , 0.1, 0. , 0.9, 0. , 0. , 0. , 0. ]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "# 随机森林不用考虑ova和ovo了，本身支持多分类\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.85177964, 0.86779339, 0.85937891])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率 折叠3次，3次交叉验证\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")\n",
    "# 精度结果不高也不低，还有优化空间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.91061788, 0.90734537, 0.91203681])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析   （分析上面10%的错误）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\wang-289\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5731,    2,   27,    8,   12,   49,   48,    7,   35,    4],\n",
       "       [   2, 6470,   51,   25,    8,   40,    7,   12,  117,   10],\n",
       "       [  54,   38, 5353,   94,   84,   24,   94,   50,  149,   18],\n",
       "       [  53,   35,  140, 5335,    1,  247,   34,   54,  134,   98],\n",
       "       [  21,   28,   38,    8, 5367,   12,   56,   28,   75,  209],\n",
       "       [  70,   39,   39,  176,   65, 4622,  114,   24,  177,   95],\n",
       "       [  33,   22,   57,    2,   39,   96, 5618,    3,   46,    2],\n",
       "       [  23,   17,   73,   29,   54,    9,    7, 5797,   14,  242],\n",
       "       [  59,  153,   74,  147,   14,  171,   53,   27, 5011,  142],\n",
       "       [  45,   27,   29,   90,  158,   37,    2,  189,   76, 5296]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 分析90%是否还有提升空间\n",
    "# 多分类混淆矩阵\n",
    "# y_train_pred是预测标签\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)  \n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx\n",
    "# 对角线是正确的，理想情况除对角线外都为0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示\n",
    "# cmap指定颜色域 可查看官网设置，现设为gray灰度过滤，值越大越亮越深越接近白色，值越小越灰\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)\n",
    "plt.show()\n",
    "# 横向是实例，纵向是预测，从图中看出，对角线第二个色块比较亮，粗看是1，1是最大概率被预测出\n",
    "# 所以优化数据没有必要优化1\n",
    "# 第5个方块最暗，说明5的预测不大好，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "# 数字5 看起来比较暗，说明有两种可能：1. 数字5图片较少  2. 分类器在数字5上执行效果不如其他数字上好\n",
    "# 假设把焦点放在错误上，为取得错误率（错误率与图片数目无关），而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "# 可以将可能1(数字5图片较少)淘汰\n",
    "# 混淆矩阵每一行的数据总和就是这个类别的图片总数\n",
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "# 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "# 此外3 容易被错分为 5，5也容易被错分为3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv（OpenCV很强大，图像转置等）对图片预处理，让显示模型更突出\n",
    "* 分析单个错误（使用pillow或OpenCV）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用图片预处理解决3和5的混淆\n",
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 左侧两个是被分类为3的图片\n",
    "# 右侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "# 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 尝试用随机森林来看看混淆矩阵，与SGD类似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5800,    1,   16,    8,    8,   14,   25,    1,   43,    7],\n",
       "       [   0, 6628,   33,   20,    8,    8,    8,   15,   13,    9],\n",
       "       [  45,   30, 5646,   51,   41,    8,   31,   39,   52,   15],\n",
       "       [  33,   23,  148, 5602,   10,  133,   11,   48,   86,   37],\n",
       "       [  19,   18,   26,    9, 5533,    7,   36,   19,   37,  138],\n",
       "       [  48,   14,   23,  200,   29, 4942,   62,    5,   62,   36],\n",
       "       [  58,   16,   28,   11,   21,   59, 5698,    4,   21,    2],\n",
       "       [  11,   33,   87,   24,   68,    5,    2, 5924,   17,   94],\n",
       "       [  37,   50,  105,  125,   55,  101,   43,   21, 5238,   76],\n",
       "       [  33,   17,   32,   81,  195,   48,    7,   97,   46, 5393]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train_scaled, y_train, cv=3)  \n",
    "conf_mx_forest = confusion_matrix(y_train, y_train_pred_forest)\n",
    "conf_mx_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.matshow(conf_mx_forest, cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_sums_forest = conf_mx_forest.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx_forest = conf_mx_forest / row_sums_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPkAAAEACAYAAABxpdD1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAALfklEQVR4nO3dT4hd93XA8e/RaOSxZFV/qGpRO8gIZIyb0KgMTmU7xQ5xSBchtFWdmBBD2iJiQrLwwki0cWgWLcR2NgGZTP4UTFK1DXZrAinIFEQViB1UQhdSVCOETRwzVh1Vai1LtqQ5XWgmNoo0c2d0f3NnTr6f1Ujv+cxhrK/ue0/33ReZiaS6Vgy9gKS2jFwqzsil4oxcKs7IpeKMXCrOyDuIiHUR8a8RsT8i/jkiVg29UxcRcWNE/GToPeYjIvZGxMeG3qOLiNgQET+IiEMR8fWh97maQSKPiG9FxI8i4q+G+P4L8Cngq5n5EWAS+OjA+3T1OHD90Et0FREfBDZn5veH3qWjTwPfzcxxYG1EjA+90JUseuQR8cfASGbuALZGxLbF3mG+MnNvZj43/ctNwIkh9+kiIj4EnOHSX0pLXkSMAt8AXoqIjw+9T0e/AN4bEeuB9wA/G3adKxviSH4P8E/TX+8H7h5ghwWJiB3Ahsx8fuhdZjP9dOKLwO6hd5mHB4EjwFeAOyLi8wPv08UPgS3AF4CfAieHXefKhoh8DfDz6a9PAjcOsMO8RcRG4GvAnw29Swe7gb2ZeWroReZhOzCRmZPAd4B7B96niy8Bn83MLwNHgc8MvM8VDRH5G7zzPPGGgXaYl+kj4/eAPZn58tD7dPBh4HMRcQB4f0R8c+B9ujgGbJ3+ehxYDj/nDcD7ImIE+ACwJN8IEov9BpWIeBD4rcx8PCL+GvivzPz7RV1iniLiIeBvgP+c/q0nM/MfB1yps4g4kJn3DL3HXCJiLfBtLj2yGwV2ZubPZ/+vhhURdwB/x6WH7D8C/igz3xh2q181ROS/ARwE/g34Q+D3M/P0oi4h/RpZ9Mjh0r8vAvcB/z79HExSI4NELmnxLPkXvSRdGyOXihss8ojYNdT3Xih3bm+57QtLf+chj+RL+gdzFe7c3nLbF5b4zj5cl4rr9dX1iFh2L9WPjIx0vm9mEhGd7js1NbXQlQazYkWbv/PnM3dqampe9z9//vxCVprT6tWrO9/3woULrFy5svP9z549u5CVZpWZZOYV/3B232xAXcNaiHXr1jWZ2+J/ZGvXXXddk7lr165tMhfglVdeaTL3tttuazIX4MiRI73PfOutt656mw/XpeKMXCrOyKXijFwqzsil4oxcKq5T5Mvw6qqSps0Z+XK8uqqkd3Q5kt/DMr26qqRukc96ddWI2DX9CRKH+l5O0rXrclrrrFdXzcwJYAKW57nrUnVdjuT/wTsP0X8XeKnZNpJ61+VI/i/AwYj4baavrtp0I0m9mvNInpn/y6UX354H7vXyydLy0umtppn5P7zzCrukZcQz3qTijFwqzsil4oxcKu7X/kKOt9xyS5O5b7zR7sMtW85eblpdl67lhTgvXLjQ+8xz584xNTV1xYsheiSXijNyqTgjl4ozcqk4I5eKM3KpOCOXijNyqTgjl4ozcqk4I5eKM3KpOCOXijNyqTgjl4ozcqk4I5eKM3KpOCOXijNyqTgjl4ozcqm4Tp+F1tXq1au5/fbb+xwJwMmTJ3ufOeP48eNN5t51111N5kK7SzK/+OKLTebedNNNTeYCjI2NNZm7fv36JnMBDh8+3PvMt99++6q3eSSXijNyqTgjl4ozcqk4I5eKM3KpOCOXijNyqbg5T4aJiHXAPwAjwBngE5l59X95l7SkdDmSfwr4amZ+BJgEPtp2JUl9mvNInpl73/XLTcCJdutI6lvnc9cjYgewITOfv+z3dwG7AFatWtXvdpKuWafII2Ij8DXgTy6/LTMngAmANWvWZK/bSbpmcz4nj4hVwPeAPZn5cvuVJPWpywtvfw78HvCXEXEgIj7ReCdJPerywtuTwJOLsIukBjwZRirOyKXijFwqzsil4oxcKq7Xq7VevHiRU6dO9TkSgHPnzvU+c8a+ffuazH3ggQeazAVYs2ZNk7lPPPFEk7mPPPJIk7lAk6sDA2zbtq3JXIDXX3+995lnz5696m0eyaXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKi4y+/tI8dHR0dy4cWNv82b0uePlrr/++iZzW1x2d8abb77ZZO7Y2FiTuVu3bm0yF9r9nDdt2tRkLsDu3bt7n/noo49y/PjxuNJtHsml4oxcKs7IpeKMXCrOyKXijFwqzsil4jpFHhE3RsRPWi8jqX9dj+SPA23OGpHU1JyRR8SHgDPAZPt1JPVt1sgjYhXwRaD/8/AkLYqVc9y+G9ibmacirnhaLBGxC9gFsGKFr+NJS81cVX4Y+FxEHADeHxHfvPwOmTmRmeOZOW7k0tIz65E8M/9g5uuIOJCZf9F+JUl96nzozcx7Gu4hqREfX0vFGblUnJFLxRm5VJyRS8UZuVTcXGe8zcvY2Bi33nprnyMBOHz4cO8zZ7S6EuyZM2eazAXYtm1bk7nHjh1rMrfVvtBu5x07djSZC/DYY4/1PnNy8upvLfFILhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4V1+vVWiOCsbGxPkf+cm4rIyMjTeauXbu2yVyAG264ocnc++67r8ncZ599tslcgJUre/0j/EsvvPBCk7kAJ06c6H3m1NTUVW/zSC4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScZ0jj4i9EfGxlstI6l+nyCPig8DmzPx+430k9WzOyCNiFPgG8FJEfLz9SpL61OVI/iBwBPgKcEdEfP7dN0bErog4FBGHzp8/32JHSdegS+TbgYnMnAS+A9z77hszcyIzxzNzfHR0tMWOkq5Bl8iPAVunvx4HXm63jqS+dXmf3reAb0fEJ4FRYGfblST1ac7IM/P/gD9dhF0kNeDJMFJxRi4VZ+RScUYuFWfkUnFGLhUXmdnbsJGRkVy9enVv82Zs3ry595kz7r777iZz9+/f32QuwPbt25vMbbXzxYsXm8yF2S9FfC02btzYZC7A/fff3/vMp59+mhMnTlzx2uUeyaXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4rp8qmlnq1atYsuWLX2OBGD9+vW9z5xx8803N5m7Z8+eJnMBnnnmmSZzH3744SZzn3vuuSZzAV599dUmcycnJ5vMBTh9+nTvM2e7Iq5Hcqk4I5eKM3KpOCOXijNyqTgjl4ozcqm4WSOPiA0R8YOIOBQRX1+spST1Z64j+aeB72bmOLA2IsYXYSdJPZor8l8A742I9cB7gJ8130hSr+aK/IfAFuALwE+Bk803ktSruSL/EvDZzPwycBT4zOV3iIhd08/ZD812/qykYcwV+QbgfRExAnwAyMvvkJkTmTmemeMjIyMtdpR0DeaK/G+BCeA0sBHY13wjSb2a9a2mmflj4HcWaRdJDXgyjFSckUvFGblUnJFLxRm5VJyRS8UZuVRcr5dkzkzOnz/f50gAjh492vvMGa+99lqTuXfeeWeTuQBPPfVUk7k7d+5sMvfIkSNN5gI89NBDTeYePHiwyVyAffsW95wyj+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnGR+SsfOb7wYRH/Dbzc8e6/Cbze2zdfHO7c3nLbF5bGzlsyc9OVbug18vmIiEOZOT7IN18gd25vue0LS39nH65LxRm5VNyQkU8M+L0Xyp3bW277whLfebDn5JIWhw/XpeKMXCrOyKXijFwqzsil4v4f+gtRr/PbqRYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.fill_diagonal(norm_conf_mx_forest, 0)\n",
    "plt.matshow(norm_conf_mx_forest, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "y_train_large = (y_train >= 7)\n",
    "y_train_odd = (y_train % 2 == 1)\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]  # 合并矩阵\n",
    "\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train, y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")\n",
    "# 0.977090"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 上面假设了所有标签都同等重要，也可以给每个标签设置一个权重（该目标标签实例的数量），设置average='weighted'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "# 训练集和测试集都加入噪声\n",
    "# 标签还是没加入噪声前的图片\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
    "X_train_mod = X_train + noise\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn_clf.fit(X_train_mod, y_train_mod)\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(clean_digit.reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
